;void generarPlasma(Color rgb);


; lo que sigue son cosas que estan en el main y que necesito en la funcion.

%define SCREEN_W 800
%define SCREEN_H 400
 
extern colores ; vector que a partir de un rgb define el color
extern screen_pixeles ; color_de_fondo


;variables globales
extern g_ver0
extern g_hor0
extern g_ver1
extern g_hor1


%define rgb [ebp+8]
%define x [ebp - 4]
%define i [ebp - 8]
%define j [ebp - 12]
%define index [ebp-16]
%define mascaraCase [ebp -20]



global generarPlasma

section .text

generarPlasma:
	push ebp
	mov ebp, esp
	sub esp, 20
	push edi 
	push esi
	push ebx
	
	mov dword i, 1 ; el indice i empieza en cero
	mov dword j, 1 ; el indice j empieza en cero
	
	mov dword x, 0 ; limpio la variable x
	
	mov edi, [screen_pixeles]	; en edi tengo puntero a pantalla
	
	mov esi, colores ; es esi tengo puntero a vector colores

ciclo1: ; ciclo filas
	xor eax, eax	
	mov dword eax, SCREEN_H

;	mov dword eax, 

	cmp i, eax
	jbe ciclo2
	jmp fin
	
ciclo2:; ciclo columnas
	mov edx, 0x000001FF ; creo una mascara para hacer el mod 512 = 2 a la 9 (comparo los 9 bits menos significativos)	
	xor eax, eax	
	mov dword eax, SCREEN_W 

;	mov dword eax, 40


	cmp j, eax
	jbe continuar
	jmp salirIteracion1	

continuar:	; adentro del ciclo columnas
	
	mov eax, j
	lea ecx, [eax + 4*eax] ; multiplicar j por 5 y lo almaceno en ecx. eax no se modifica.
	
	mov ebx, [g_ver0]

	add ebx, ecx ; tengo el resultado de la primera parte del indice del vector colores

	and ebx, edx ; tengo el indice del vector a partir de la mascara

		
	mov dword ecx, x ; piso ecx. Ahora ecx = x (acumulado)
	
	add  ecx, [esi+ebx*4] ; ecx = ecx + colores[ebx]. Colores es un vector de enteros

	mov dword x, ecx ; x = resultado de x+colores[ebx]
	
;segundo sumando
	lea ecx, [eax + 2*eax] ; multiplicar j por 3 y lo almaceno en ecx. eax no se modifica.
	
	mov ebx, [g_ver1]	

	add ebx, ecx ; tengo el resultado de la primera parte del indice del vector colores

	and ebx, edx ; tengo el indice del vector 

	mov dword ecx, x	

	add ecx, [esi+ebx*4]

	mov dword x, ecx	

;tercer sumando
	mov eax, i
	lea ecx, [eax + 2*eax] ; multiplicar i por 3 y lo almaceno en ecx. eax no se modifica.
	mov ebx, [g_hor0]
	add ebx, ecx ; tengo el resultado de la primera parte del indice del vector colores
	and ebx, edx ; tengo el indice del vector .En edx tengo la mascara
	
	mov dword ecx, x
	
	add ecx, [esi+ebx*4]

	mov dword x, ecx	

;cuarto sumando
	mov ebx, [g_hor1]	
	add ebx, eax ; a la variable global g_hor1 le sumo el indice i
	and ebx, edx ; tengo el indice del vector . En edx tengo la mascara

	mov dword ecx, x

	add ecx, [esi+ebx*4]	

	mov x, ecx ; x tiene acumulada la suma

;inicializar index
	shr dword x, 4
	add dword x, 128
	
	mov ebx, x
	mov index, ebx ; index = x * 4 +128
	
preparadatos:
	mov edx, rgb

	mov ecx, edx
	and ecx, 0x000000ff ; obtengo el blue
	cmp [edi+0], cl
	je comparaGreen
	jmp salirIteracion2

comparaGreen:
		
	mov ecx, edx
	and ecx, 0x0000ff00 ; obtengo el green
	shr ecx,8 ; para obtenerlo en la parte mas baja
	cmp [edi+1], cl
	je comparaRed
	jmp salirIteracion2

comparaRed:
	mov ecx, edx
	and ecx, 0x00ff0000 ; obtengo el red
	shr ecx, 16	
	cmp byte [edi+0], cl
	je case1
	jmp salirIteracion2


case1:
;me fijo si entro al case index >=256
		
	xor ebx, ebx
	mov bl, index

	cmp ebx, 256;  
	jb case2

	mov byte [edi+0], 0

	mov byte [edi+1], 0

	mov byte [edi+2], 0

	jmp salirIteracion2	

case2:
	xor ebx, ebx
	mov bl, index	

	cmp ebx, 192;  .
	jb case3	; el numero es menor
	
	mov byte [edi+2], 0 ; pone blue en cero

	mov byte [edi+1], 0 ; pone green en cero

	shl bl, 2
	inc bl

	mov byte [edi+0], bl ; red = bl


	jmp salirIteracion2


case3:
	xor ebx, ebx
	mov bl, index
	cmp ebx, 128;  .
	jb case4	; el numero es menor
	

	mov byte [edi+2], 0 ; pone blue en cero


	shl bl, 2
	inc bl
	
	xor ecx, ecx
	mov cl, 255 ; supongo que entra en 8 bits	
	sub cl, bl

	mov byte [edi+1], cl ; pone green 

	mov byte [edi+0], cl ; pone red


	jmp salirIteracion2

case4:
	xor ebx, ebx
	mov bl, index
	cmp ebx, 64;  .
	jb case5	; el numero es menor
	
	shl bl, 2
	inc bl

	xor ecx, ecx
	mov cl, 255 ; supongo que entra en 8 bits	
	sub cl, bl


	mov byte [edi+2], 0

	mov byte [edi+1], 255

	mov byte [edi+0], cl

	jmp salirIteracion2


case5:

	xor ebx, ebx
	mov bl, index

	shl bl, 2
	

	mov byte [edi+2], 0 ; blue

	mov byte [edi+1], bl ; green
	
	inc bl
	xor ecx, ecx
	mov cl, 255 ; supongo que entra en 8 bits	
	sub cl, bl


	mov byte [edi+0], cl

	
salirIteracion2:
	add dword j, 1
	add edi, 3
	mov dword x, 0
	jmp ciclo2

salirIteracion1:
	mov dword j, 1
	add dword i, 1
		
	jmp ciclo1


fin: 
	add dword [g_ver0] , 9
	add dword [g_hor0] , 8	

	add esp, 20
	pop ebx
	pop esi
	pop edi
	pop ebp
	ret
